```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HashMap扩容机制深度解析</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #111827;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .card:hover {
            transform: translateY(-4px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .highlight {
            background: linear-gradient(90deg, rgba(79, 70, 229, 0.1) 0%, rgba(124, 58, 237, 0.1) 100%);
            border-left: 4px solid #4f46e5;
        }
        .icon-box {
            width: 48px;
            height: 48px;
            display: flex;
            align-items: center;
            justify-content: center;
            border-radius: 12px;
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
        }
        .expandable {
            cursor: pointer;
        }
        .expandable:hover {
            background-color: rgba(79, 70, 229, 0.05);
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 md:py-28">
        <div class="max-w-4xl mx-auto text-center">
            <div class="flex justify-center mb-6">
                <div class="icon-box">
                    <i class="fas fa-expand-alt text-2xl"></i>
                </div>
            </div>
            <h1 class="text-4xl md:text-5xl font-bold mb-6">HashMap扩容机制深度解析</h1>
            <p class="text-xl md:text-2xl opacity-90 max-w-3xl mx-auto">探索Java中HashMap扩容的原理、时机与性能优化策略</p>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="bg-white rounded-xl p-6 md:p-8 card">
                <p class="text-lg md:text-xl leading-relaxed">
                    在 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 中，当需要存储的键值对数量超过了当前容量所能容纳的上限时，就会触发扩容（resize）操作。扩容的目的是增加哈希表的容量，以减少哈希冲突并提高访问效率。但也会带来一定的性能开销。因此，在使用 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 时，合理地设置初始容量和负载因子，可以减少扩容的频率，从而提升性能。
                </p>
            </div>
        </section>

        <!-- Key Concepts -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-key mr-3 text-indigo-600"></i>
                核心概念解析
            </h2>
            
            <div class="grid md:grid-cols-2 gap-6">
                <!-- Capacity -->
                <div class="bg-white rounded-xl p-6 card">
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-arrows-alt-h mr-2 text-indigo-500"></i>
                        容量 (capacity)
                    </h3>
                    <p class="mb-4">
                        <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 的容量是桶数组的长度，即可以存储的键值对的最大数量（不考虑哈希冲突）。
                    </p>
                    <div class="highlight p-4 rounded-lg">
                        <p class="font-mono text-sm">
                            // 默认初始容量为16<br>
                            static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16
                        </p>
                    </div>
                </div>
                
                <!-- Load Factor -->
                <div class="bg-white rounded-xl p-6 card">
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-balance-scale mr-2 text-indigo-500"></i>
                        负载因子 (load factor)
                    </h3>
                    <p class="mb-4">
                        负载因子是一个用于衡量 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 装满程度的参数，默认为 <code class="bg-gray-100 px-2 py-1 rounded-md">0.75</code>。它表示在触发扩容之前，<code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 能够使用的容量比例。
                    </p>
                    <div class="highlight p-4 rounded-lg">
                        <p class="font-mono text-sm">
                            // 默认负载因子<br>
                            static final float DEFAULT_LOAD_FACTOR = 0.75f;
                        </p>
                    </div>
                </div>
                
                <!-- Threshold -->
                <div class="bg-white rounded-xl p-6 card">
                    <h3 class="text-xl font-semibold mb-4 flex items-center">
                        <i class="fas fa-tachometer-alt mr-2 text-indigo-500"></i>
                        阈值 (threshold)
                    </h3>
                    <p>
                        触发扩容的临界点，计算方法为 <code class="bg-gray-100 px-2 py-1 rounded-md">容量 × 负载因子</code>。当 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 中的键值对数量超过这个阈值时，就会触发扩容。
                    </p>
                </div>
            </div>
        </section>

        <!-- When to Resize -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-clock mr-3 text-indigo-600"></i>
                何时触发扩容
            </h2>
            
            <div class="bg-white rounded-xl p-6 md:p-8 card mb-8">
                <h3 class="text-xl font-semibold mb-4">扩容通常发生在以下情况下：</h3>
                <div class="space-y-4">
                    <div class="expandable p-4 rounded-lg transition-colors">
                        <h4 class="font-medium flex items-center">
                            <i class="fas fa-plus-circle mr-2 text-indigo-500"></i>
                            插入新键值对时
                        </h4>
                        <p class="mt-2 pl-6">
                            每当向 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 插入一个新的键值对时，<code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 会检查当前存储的键值对数量是否已经超过了阈值。如果超过了，则会触发扩容。
                        </p>
                    </div>
                    
                    <div class="expandable p-4 rounded-lg transition-colors">
                        <h4 class="font-medium flex items-center">
                            <i class="fas fa-cog mr-2 text-indigo-500"></i>
                            初始化时指定较小的容量
                        </h4>
                        <p class="mt-2 pl-6">
                            如果在 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 初始化时指定了较小的容量，但随着插入的数据增多，超过了由初始容量和负载因子计算得出的阈值，也会触发扩容。
                        </p>
                    </div>
                </div>
            </div>
            
            <div class="bg-indigo-50 rounded-xl p-6">
                <h3 class="text-xl font-semibold mb-4 flex items-center">
                    <i class="fas fa-info-circle mr-2 text-indigo-600"></i>
                    示例说明
                </h3>
                <p class="mb-4">
                    假设一个 <code class="bg-gray-200 px-2 py-1 rounded-md">HashMap</code> 初始化时的容量为 16，负载因子为默认的 0.75，那么其阈值为 <code class="bg-gray-200 px-2 py-1 rounded-md">16 × 0.75 = 12</code>。当插入第 13 个键值对时，<code class="bg-gray-200 px-2 py-1 rounded-md">HashMap</code> 就会触发扩容，将容量扩展为 32，并重新分配现有的所有键值对。
                </p>
                <div class="mermaid">
                    graph TD
                        A[初始容量: 16] --> B[阈值: 12]
                        B --> C{当前size > 12?}
                        C -->|是| D[扩容至32]
                        C -->|否| E[继续插入]
                </div>
            </div>
        </section>

        <!-- Resize Process -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-cogs mr-3 text-indigo-600"></i>
                扩容的具体操作
            </h2>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="bg-white rounded-xl p-6 card">
                    <div class="icon-box mb-4">
                        <i class="fas fa-plus-square"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">创建新数组</h3>
                    <p>
                        新数组的容量通常是旧数组容量的两倍。这使得哈希表中的冲突概率降低，插入效率提高。
                    </p>
                </div>
                
                <div class="bg-white rounded-xl p-6 card">
                    <div class="icon-box mb-4">
                        <i class="fas fa-calculator"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">重新计算哈希</h3>
                    <p>
                        <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 会将原数组中的所有键值对重新哈希，计算它们在新数组中的位置。
                    </p>
                </div>
                
                <div class="bg-white rounded-xl p-6 card">
                    <div class="icon-box mb-4">
                        <i class="fas fa-sync-alt"></i>
                    </div>
                    <h3 class="text-xl font-semibold mb-3">迁移数据</h3>
                    <p>
                        <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 会将旧数组中的所有键值对迁移到新数组中，并更新它们在新数组中的位置。
                    </p>
                </div>
            </div>
        </section>

        <!-- Impact of Resizing -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-chart-line mr-3 text-indigo-600"></i>
                扩容的影响与优化
            </h2>
            
            <div class="bg-white rounded-xl p-6 md:p-8 card">
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 flex items-center">
                            <i class="fas fa-exclamation-triangle mr-2 text-yellow-500"></i>
                            性能开销
                        </h3>
                        <p class="mb-4">
                            扩容是一项开销较大的操作，因为它需要重新哈希和迁移所有现有的键值对。因此，在设计系统时，应尽量避免频繁触发扩容。
                        </p>
                        <div class="bg-yellow-50 p-4 rounded-lg border border-yellow-200">
                            <p class="font-medium text-yellow-800">
                                <i class="fas fa-lightbulb mr-2"></i>
                                优化建议：通过指定合适的初始容量来减少扩容的次数
                            </p>
                        </div>
                    </div>
                    
                    <div>
                        <h3 class="text-xl font-semibold mb-4 flex items-center">
                            <i class="fas fa-chart-bar mr-2 text-green-500"></i>
                            容量增长
                        </h3>
                        <p>
                            每次扩容后，<code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 的容量会增加一倍，这也意味着新的阈值会相应增加，使得 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 能够容纳更多的键值对而不会再次扩容。
                        </p>
                    </div>
                </div>
                
                <div class="mt-8 p-6 bg-gray-50 rounded-lg">
                    <h4 class="font-semibold mb-3">容量增长过程示例：</h4>
                    <div class="mermaid">
                        graph LR
                            A[初始:16] -->|达到12元素| B[扩容至32]
                            B -->|达到24元素| C[扩容至64]
                            C -->|达到48元素| D[扩容至128]
                    </div>
                </div>
            </div>
        </section>

        <!-- Best Practices -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <i class="fas fa-check-circle mr-3 text-indigo-600"></i>
                最佳实践
            </h2>
            
            <div class="bg-white rounded-xl p-6 md:p-8 card">
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 flex items-center">
                            <i class="fas fa-tools mr-2 text-indigo-500"></i>
                            合理设置初始容量
                        </h3>
                        <p class="mb-4">
                            如果能预估 <code class="bg-gray-100 px-2 py-1 rounded-md">HashMap</code> 中将要存储的元素数量，应该在创建时就指定一个合适的初始容量，避免频繁扩容。
                        </p>
                        <div class="highlight p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                // 预估需要存储100个元素<br>
                                int initialCapacity = (int) (100 / 0.75) + 1;<br>
                                Map<String, String> map = new HashMap<>(initialCapacity);
                            </p>
                        </div>
                    </div>
                    
                    <div>
                        <h3 class="text-xl font-semibold mb-4 flex items-center">
                            <i class="fas fa-sliders-h mr-2 text-indigo-500"></i>
                            调整负载因子
                        </h3>
                        <p class="mb-4">
                            对于对内存敏感但对性能要求不高的场景，可以适当增加负载因子；对于追求性能的场景，可以适当降低负载因子。
                        </p>
                        <div class="highlight p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                // 降低负载因子以减少冲突<br>
                                Map<String, String> map = new HashMap<>(16, 0.5f);
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-12">
        <div class="max-w-5xl mx-auto px-4">
            <div class="text-center">
                <h3 class="text-xl font-semibold text-white mb-2">技术小馆</h3>
                <p class="mb-4">深入技术细节，探索编程之美</p>
                <a href="http://www.yuque.com/jtostring" class="text-indigo-400 hover:text-indigo-300 transition-colors" target="_blank">
                    <i class="fas fa-external-link-alt mr-1"></i>
                    http://www.yuque.com/jtostring
                </a>
            </div>
        </div>
    </footer>

    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true
            }
        });

        // Expandable sections
        document.querySelectorAll('.expandable').forEach(item => {
            const heading = item.querySelector('h4');
            const content = item.querySelector('p');
            const icon = item.querySelector('i');
            
            // Initially hide content
            content.style.display = 'none';
            
            heading.addEventListener('click', () => {
                if (content.style.display === 'none') {
                    content.style.display = 'block';
                    icon.classList.remove('fa-plus-circle');
                    icon.classList.add('fa-minus-circle');
                } else {
                    content.style.display = 'none';
                    icon.classList.remove('fa-minus-circle');
                    icon.classList.add('fa-plus-circle');
                }
            });
        });
    </script>
</body>
</html>
```